﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;
using Microsoft.Xna.Framework.Net;
using Microsoft.Xna.Framework.Storage;

namespace h2100
{
    /// <summary>
    /// Lưới canh vật thể
    /// </summary>
    public class hGrid
    {
        #region Properties

        private Point _selGrid = new Point(-1,-1);
        public Point SelectedGrid
        {
            get { return _selGrid; }
            set { _selGrid = value; }
        }

        private float _width = 0;
        public float Width
        {
            get { return _width; }
            set { _width = value; }
        }
        private float _height = 0;
        public float Height
        {
            get { return _height; }
            set { _height = value; }
        }

        private float _x;
        /// <summary>
        /// Tọa độ X góc trái trên của lưới
        /// Thay đổi giá trị thông qua nextX
        /// X KHÔNG cập nhật ngay sau khi gán nextX
        /// </summary>
        public float X
        {
            get { return _x; }
            //set 
            //{
            //    //dX = value - _x;
            //    _x = value;
            //}
        }

        private float _y;
        /// <summary>
        /// Tọa độ Y góc trái trên của lưới
        /// Thay đổi giá trị thông qua nextY
        /// Y KHÔNG cập nhật ngay sau khi gán nextY
        /// </summary>
        public float Y
        {
            get { return _y; }
            //set 
            //{
            //    //dY = value - _y;
            //    _y = value;
            //}
        }

        private float _nextx;
        /// <summary>
        /// Tọa độ X mới góc trái trên của lưới 
        /// </summary>
        public float nextX
        {
            get { return _nextx; }
            set
            {
                //dX = value - _x;
                _nextx = value;
            }
        }

        private float _nexty;
        /// <summary>
        /// Tọa độ Y mới góc trái trên của lưới
        /// </summary>
        public float nextY
        {
            get { return _nexty; }
            set
            {
                //dY = value - _y;
                _nexty = value;
            }
        }

        private float _dX=0;
        /// <summary>
        /// Chênh lệch X cũ và mới
        /// </summary>
        public float dX
        {
            get { return _dX; }
            set { _dX = value; }
        }

        private float _dY = 0;
        /// <summary>
        /// Chênh lệch Y cũ và mới
        /// </summary>
        public float dY
        {
            get { return _dY; }
            set { _dY = value; }
        }

        private int _nRows;
        /// <summary>
        /// Số dòng
        /// </summary>
        public int NRows
        {
            get { return _nRows; }
            set { _nRows = value; }
        }

        private int _nColumns;
        /// <summary>
        /// Số cột
        /// </summary>
        public int NColumns
        {
            get { return _nColumns; }
            set { _nColumns = value; }
        }

        private Vector2[,] _grid;
        /// <summary>
        /// Lưới
        /// </summary>
        public Vector2[,] Grid
        {
            get { return _grid; }
            set { _grid = value; }
        }

        #endregion

        /// <summary>
        /// Tạo lưới dòng x cột
        /// </summary>
        /// <param name="nRows">Số dòng</param>
        /// <param name="nColumns">Số cột</param>
        public hGrid(int nRows, int nColumns)
        {
            _x = 0;
            _y = 0;
            _nRows=nRows;
            _nColumns=nColumns;
            Width = nColumns * hGlobal.MapCellWidth;
            Height = nRows * hGlobal.MapCellHeight;
            _grid = new Vector2[_nRows, _nColumns];
            for(int i=0;i<_nRows;i++)
                for (int j = 0; j < _nColumns; j++)
                {
                    _grid[i, j] = new Vector2(j * hGlobal.MapCellWidth, i * hGlobal.MapCellHeight);
                }
        }

        ///// <summary>
        ///// Lấy vị trí (dòng, cột) của mắt lưới đang chọn bằng chuột
        ///// </summary>
        ///// <returns></returns>
        //public Point getSelectingCell()
        //{
        //    Point v = new Point();
        //    MouseState mouse = Mouse.GetState();
        //    v.X = ((mouse.X - (int)X) / hGlobal.MapCellWidth);
        //    v.Y = (mouse.Y - (int)Y) / hGlobal.MapCellHeight;
        //    return v;
        //}

        public int nDelay = 1;
        protected int iDelay = 0;

        public void update( hParams args )
        {
            float tempX = X;
            float tempY = Y;

            // Nếu đã có lệnh can thiệp từ ngoài
            if((nextX!=X)||(nextY!=Y))
            {
                dX = nextX - X;
                dY = nextY - Y;
                _x=nextX;
                _y=nextY;
                return;
            }

            // cập nhật vị trí mắt lưới
            KeyboardState keyState = Keyboard.GetState();

            if (iDelay == 0)
            {
                nDelay = 1;
                if (keyState.IsKeyDown(Keys.Up)||keyState.IsKeyDown(Keys.W))
                {
                    if (Y < 0)
                    {
                        if (Y + 30 < 0)
                        {
                            _y += 30;
                        }
                        else
                        {
                            _y = 0;
                        }
                    }
                    nDelay = 10;
                }
                if (keyState.IsKeyDown(Keys.Down) || keyState.IsKeyDown(Keys.S))
                {
                    if (Y > hGlobal.ViewHeight - Height)
                    {
                        if (Y - 30 > hGlobal.ViewHeight - Height)
                        {
                            _y -= 30;
                        }
                        else
                        {
                            _y = hGlobal.ViewHeight - Height;
                        }
                    }
                    nDelay = 10;
                }
                if (keyState.IsKeyDown(Keys.Right) || keyState.IsKeyDown(Keys.D))
                {
                    if (X > hGlobal.ViewWidth - Width)
                    {
                        if (X - 30 > hGlobal.ViewWidth - Width)
                        {
                            _x -= 30;
                        }
                        else
                        {
                            _x = hGlobal.ViewWidth - Width;
                        }
                    }
                    nDelay = 10;
                }
                if (keyState.IsKeyDown(Keys.Left) || keyState.IsKeyDown(Keys.A))
                {
                    if (X < 0)
                    {
                        if (X + 30 < 0)
                        {
                            _x += 30;
                        }
                        else
                        {
                            _x = 0;
                        }
                    }
                    nDelay = 10;
                }

                for (int i = 0; i < _nRows; i++)
                {
                    for (int j = 0; j < _nColumns; j++)
                    {
                        _grid[i, j].X = X + j * hGlobal.MapCellWidth;
                        _grid[i, j].Y = Y + i * hGlobal.MapCellHeight;
                    }
                }

            }
            iDelay = (iDelay + 1) % nDelay;

            dX = X - tempX;
            dY = Y - tempY;
            nextX = X;
            nextY = Y;

            MouseState mouse = Mouse.GetState();
            if (args.IsMouseOverMap && mouse.LeftButton == ButtonState.Pressed)
            {
                SelectedGrid = new Point((int)((mouse.Y - Y) / hGlobal.MapCellHeight),(int)((mouse.X - X) / hGlobal.MapCellWidth));
            }
            else
            {
                SelectedGrid = new Point(-1, -1);
            }


            // kết thúc cập nhật vị trí mắt lưới       
            
            // cập nhật nền công trình             
            for (int i = 0; i < args.Grid.NRows; i++)
            {
                for (int j = 0; j < args.Grid.NColumns; j++)
                {
                    if (args.StructureManager.Structures[i, j] != null)
                    {
                        args.MapManager.Map.MapCells[i, j].isFreeToBuild = false;
                        args.MapManager.Map.MapCells[i, j].setPlatform(args, args.StructureManager.Structures[i, j].Controler);
                    }
                }
            }
            // kết thúc cập nhật nền công trình
        }
    }
}
